//import java.util.Arrays;
/*import java.util.Arrays;
import java.util.Date;*/

import com.bite.www.TestDemo;

import java.util.Date;
import java.util.Arrays;

//以下的导包方式不推荐
import java.util.*;
import java.sql.*;

/*
* 号叫做通配符
 */

//一般不写
/*import static java.lang.Math.*;//静态导入 Math 这个类底下爱的所有方法
import static java.lang.System.*;*/

/**
 * Created with IntelliJ IDEA.
 * Description:类和对象2
 * User: liangyuanzhang
 * Date: 2024-12-06
 * Time: 15:55
 */

/*
对于面向对象的语言来说，有几个比较重要的特性：封装、继承、多态
这里有一个误区：这三个特征 不是哪个语言的特征，他是面向对象的特征

1.封装
什么是封装 封装的作用/意义是什么？
举例：手机。你是看不到任何内容实现细节的。   从语言上来说，我想达到同样的目的，只能通过对类进行封装。把细节隐藏起来。
     留一些公开的 接口给你使用，          提供一些拟公开可以访问的内容就可以了

总结：就是对成员变量或者成员方法 使用 private 进行修饰
达到的效果：就是该成员变量 或者 该成员方法，此时只能再当前类中使用，不能在当前类外使用
实际上封装就是：对外隐藏 类 内部的实现细节，
 */

/*
    publi private protected 这些叫做：访问修饰限定符（管当前修饰的字段或者方法的访问权限的）
 */
class Student{
    //字段 属性    成员变量：定义在类当中，方法的外边的
    public String name;
    private int age;
    private String stuNum;//学号
    //呗static修饰的成员 不属于对象
    public static String className;//班级

    //编译器帮我生成
    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public String getStuNum() {
        return stuNum;
    }

    public void setStuNum(String stuNum) {
        this.stuNum = stuNum;
    }

    /*    public  String getName(){//对应序号一
            return this.name;
        }

        public void setName(String name){//对应序号二
            this.name = name;
        }*/
    /*这个构造方法    如果当前类中没有提供任何构造方法
    Java会默认提供一个不带参数的构造方法*/
    public Student(){
        //this("zhangsan",10,"123456789");//在构造方法里面调用带有三个参数的构造方法
        //this()调用其他构造方法时，必须是在构造方法的第一行
        System.out.println("不带参数的构造方法......");
    }

/*    public Student(String name,int age,String stuNum){
        this.name = name;
        this.age  = age;
        this.stuNum = stuNum;
        System.out.println("调用了带有3个参数的构造方法......");
    }*/

    //      Generate自动生成
    public Student(String name, int age, String stuNum) {
        this.name = name;
        this.age = age;
        this.stuNum = stuNum;
    }
    //......

    //成员方法
    /*
    1.this.成员变量
    2.this.尘缘方法
    3.this()调用当前对象的其他构造方法
     */
    public void eat(){
        System.out.println(this.name+"正在吃饭！");
    }
    public void doClass(){
        func();
        System.out.println(this.name+"正在上课！");
    }
    private void func(){
        //其他的业务操作
        System.out.println("这个方法就是为本类其他访问的 不对外公开");
    }

    public void show(){
        System.out.println("姓名： "+this.name+"年龄： "+this.age+"学号： "
                +this.stuNum+"班级： "+this.className);
    }
}

public class Test {
    public static void main(String[] args) {
        //有一句话记住：静态的 不依赖对象。意味着 不需要对象的引用 来访问
        Student.className = "1班";


        Student student1 = null;
        /*student1.className = "1班";
        System.out.println(student1.className);*/

        System.out.println(student1.name);//依赖对象，空指针异常
    }

    public static void main6(String[] args) {
        Student student1 = new Student("zahngsan",10,"1234");
        /*
        1.通过对象的引用访问
        2.通过类名访问
        哪个好？
        前提：静态成员变量，也叫做类变量。也就是说，这个变量属于类的，不是对象的。
        虽然 都是可以访问的，但是我们建议 通过类名来访问。
         */
        //student1.className = "1班";
        Student.className = "1班";

        student1.show();

        Student student2 = new Student("Lisi",12,"12345");

        student2.show();
    }

    public static void main5(String[] args) {
        TestDemo testDemo = new TestDemo();
        //System.out.println(testDemo.a);
    }









    public static void main4(String[] args) {
        double x = 30;
        double y = 40;
        // 静态导入的方式写起来更方便一些.
        //double result = Math.sqrt(Math.pow(x, 2) + Math.pow(y, 2));
       /* double result = sqrt(pow(x, 2) + pow(y, 2));//静态导入 Math 这个类底下爱的所有方法
        //System.out.println(result);
        out.println(result);*/
    }
    public static void main3(String[] args) {
        int[] array = {1,2,3,4,5};
        //System.out.println(java.util.Arrays.toString(array));
        System.out.println(Arrays.toString(array));


        //java.util.Date date = new java.util.Date();
        Date date = new Date();

        //Arrays

        java.sql.Date date1 = new java.sql.Date(10);//当两个Date,导入的两个包都有Date,这时候其中一个Date必须指明它的路径
        //Date date1 = new Date(10);


    }
    public static void main2(String[] args) {
        //Student student2 = new Student("zahngsan",10,"1234");
        //在实例化对象的时候一定会调用构造方法
        Student student1 = new Student();

        //student1.name = "zhangsan";

        student1.setName("zahngsan");//对应序号二
        System.out.println(student1.getName());//对应序号一
        student1.setAge(10);
        System.out.println(student1.getAge());
        student1.setStuNum("12345");
        System.out.println(student1.getStuNum());

    }

   /* public static void main1(String[] args) {
        //对象的实例化
        Student student1 = new Student();
        student1.name = "zhangsan";
        student1.age = 10;
        student1.stuNum = "20241003";
        System.out.println(student1.name);
        System.out.println(student1.age);
        System.out.println(student1.stuNum);
        student1.doClass();
        student1.eat();
        System.out.println("===============");

        Student student2 = new Student();
        student2.name = "Lisi";
        student2.age = 12;
        student2.stuNum = "20241013";
        System.out.println(student2.name);
        System.out.println(student2.age);
        System.out.println(student2.stuNum);
        student2.doClass();
        student2.eat();
    }*/

}

/*
new 关键字背后所发生的一些事情：
1.优点：之前被加载过的类 不会再重复加载了
2. 为对象分配内存空间
3. 处理并发安全问题
比如：多个线程同时申请对象，JVM要保证给对象分配的空间不冲突
4. 初始化所分配的空间
 */

/*
总结类和对象第一块小知识
1.定义类
2.实例化对象得清楚
3.通过对象的引用 访问对象的属性 得清楚
4. 理解this
5.理解构造方法
 */
